// 版权归Go作者所有。版权所有。
// 此源代码的使用受BSD样式的约束
// 可以在许可证文件中找到的许可证。

// go:构建忽略
// +构建忽略

// 从cmd/compile/internal/typecheck/builtin/runtime.go生成builtinlist.go。

package main

import (
	"bytes"
	"flag"
	"fmt"
	"go/ast"
	"go/format"
	"go/parser"
	"go/token"
	"io"
	"io/ioutil"
	"log"
	"os"
	"path/filepath"
	"strings"
)

var stdout = flag.Bool("stdout", false, "write to stdout instead of builtinlist.go")

func main() {
	flag.Parse()

	var b bytes.Buffer
	fmt.Fprintln(&b, "// 由mkbuiltin.go生成的代码。不要编辑。”）
	fmt.Fprintln(&b)
	fmt.Fprintln(&b, "package goobj")

	mkbuiltin(&b)

	out, err := format.Source(b.Bytes())
	if err != nil {
		log.Fatal(err)
	}
	if *stdout {
		_, err = os.Stdout.Write(out)
	} else {
		err = ioutil.WriteFile("builtinlist.go", out, 0666)
	}
	if err != nil {
		log.Fatal(err)
	}
}

func mkbuiltin(w io.Writer) {
	pkg := "runtime"
	fset := token.NewFileSet()
	path := filepath.Join("..", "..", "compile", "internal", "typecheck", "builtin", "runtime.go")
	f, err := parser.ParseFile(fset, path, nil, 0)
	if err != nil {
		log.Fatal(err)
	}

	decls := make(map[string]bool)

	fmt.Fprintf(w, "var builtins = [...]struct{ name string; abi int }{\n")
	for _, decl := range f.Decls {
		switch decl := decl.(type) {
		case *ast.FuncDecl:
			if decl.Recv != nil {
				log.Fatal("methods unsupported")
			}
			if decl.Body != nil {
				log.Fatal("unexpected function body")
			}
			declName := pkg + "." + decl.Name.Name
			decls[declName] = true
			fmt.Fprintf(w, "{%q, 1},\n", declName) // 功能是内部的（1）
		case *ast.GenDecl:
			if decl.Tok == token.IMPORT {
				continue
			}
			if decl.Tok != token.VAR {
				log.Fatal("unhandled declaration kind", decl.Tok)
			}
			for _, spec := range decl.Specs {
				spec := spec.(*ast.ValueSpec)
				if len(spec.Values) != 0 {
					log.Fatal("unexpected values")
				}
				for _, name := range spec.Names {
					declName := pkg + "." + name.Name
					decls[declName] = true
					fmt.Fprintf(w, "{%q, 0},\n", declName) // 变量为ABI0
				}
			}
		default:
			log.Fatal("unhandled decl type", decl)
		}
	}

	// 上面的列表仅包含前端使用的列表。
	// 后端可能会创建更多的内置函数引用。
	// 我们还希望包括预定义的类型。
	// 添加它们。
	extras := append(fextras[:], enumerateBasicTypes()...)
	for _, b := range extras {
		prefix := ""
		if !strings.HasPrefix(b.name, "type.") {
			prefix = pkg + "."
		}
		name := prefix + b.name
		if decls[name] {
			log.Fatalf("%q already added -- mkbuiltin.go out of sync?", name)
		}
		fmt.Fprintf(w, "{%q, %d},\n", name, b.abi)
	}
	fmt.Fprintln(w, "}")
}

// addBasicTypes返回以下基本类型的符号名称：
// 在运行时中定义并在其他包中引用。
// 需要与reflect.go保持同步：WriteBasicTypes（）和
// reflect.go:编译器中的writeType（）。
func enumerateBasicTypes() []extra {
	names := [...]string{
		"int8", "uint8", "int16", "uint16",
		"int32", "uint32", "int64", "uint64",
		"float32", "float64", "complex64", "complex128",
		"unsafe.Pointer", "uintptr", "bool", "string", "error",
		"func(error) string"}
	result := []extra{}
	for _, n := range names {
		result = append(result, extra{"type." + n, 0})
		result = append(result, extra{"type.*" + n, 0})
	}
	return result
}

type extra struct {
	name string
	abi  int
}

var fextras = [...]extra{
	// 编译器前端插入调用（sysfunc）
	{"deferproc", 1},
	{"deferprocStack", 1},
	{"deferreturn", 1},
	{"newproc", 1},
	{"panicoverflow", 1},
	{"sigpanic", 1},

	// 编译器后端插入调用
	{"gcWriteBarrier", 0}, // asm函数，ABI0

	// 汇编程序后端插入调用
	{"morestack", 0},        // asm函数，ABI0
	{"morestackc", 0},       // asm函数，ABI0
	{"morestack_noctxt", 0}, // asm函数，ABI0
}
